//1-1
const promise=new Promise(function(resolve,reject){
      resolve('hello') //成功
})

promise.then(value=>{
    
    let b='lagou';
   // console.log(value+b)
    return value+b;
}).then(value=>{
    let c='I ❤️ U';
    console.log(value+c)
})

//2-1
let isLastInStock = function(cars){
    // 获取最后一条数据
    let last_car = fp.last(cars)
    // 获取最后一条数据的 in_stock 属性值
    return fp.prop('in_stock', last_car)
}
let isLastInStock=fp.flowRight(fp.prop('in_stock'),fp.last);
console.log(isLastInStock(cars))



//2-2

//先定义获取第一条数据的函数，再定义获取某个对象中的 name 属性的函数，再用 fp.flowRight 组合函数

let isFirstName=fp.flowRight(fp.prop('name'),fp.first);
console.log(isFirstName(cars))


//2-3
let _average = function(xs){
    return fp.reduce(fp.add, 0, xs) / xs.length
}

//先定义获取某个对象中的 dollar_value 属性的函数，将该函数作为 fp.map 的数组元素处理函数，再用 fp.flowRight 组合函数
let _average=function(xs){
    return fp.reduce(fp.add,0,xs) /xs.length
}
let averageDollarValue=fp.flowRight(_average,fp.map('dollar_value'))
console.log(averageDollarValue(cars))


//2-4
let _underscore = fp.replace(/\W+/g, '_') // 无须改动，并在 sanitizeNames 中使用它

//先定义获取某个对象中的 name 属性的函数，再定义转化为小写的函数，再将空格和下划线替换，,再用 fp.flowRight 组合函数
let _underscore=fp.replace(/\W+/g,'_');

let sanitizeNames=fp.flowRight(_underscore,fp.toLower,fp.map('name'));
console.log(sanitizeNames(cars))


//3-1
const fp=require('lodash/fp');
const {Maybe,Container}=require('./support');

let maybe=Maybe.of([5,6,1]);
let ex1=()=>{
        maybe.map(x=>fp.map(function(value){
            return fp.add(value,1);
        },x))
}
ex1();


//3-2
let xs = Container.of(['do', 'ray', 'me', 'fa', 'so', 'la', 'ti', 'do'])
let ex2 = () => {
    return xs.map(x=>fp.first(x));
}
ex2();

let safeProp=fp.curry(function(x,o){
    return Maybe.of(o[x])
})


//3-3
let user={id:2,name:'Albert'};
let ex3=()=>{
    //调用safeProp,safeProp 是经过柯里化处理的，可以先传“属性”参数，后传“对象”参数。
    //safeProp 函数处理后返回 user 的name值，再调用fp.first 获取首字母
    safeProp('name',user).map(x=>fp.first(x))
}
ex3();

//3-4
// let ex4=function(n){
//     if(n){
//         return parseInt(n)
//     }
// }
let ex4=(n)=>{
    return Maybe.of(n).map(x=>parseInt(x))
}
console.log(ex5('123'))





